package com.myspring;


import com.myspring.anno.MyAutowired;
import com.myspring.anno.MyComponent;
import com.myspring.anno.MyComponentScan;
import com.myspring.anno.MyQualifier;
import com.myspring.anno.MyScope;

import com.myspring.aware.*;
import com.myspring.aware.SmartInstantiationAwareBeanPostProcessor;
import com.myspring.springaop.AdvisorAutoProxyCreator;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.URL;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.function.Function;
import java.util.stream.Collectors;

import static jdk.nashorn.internal.objects.NativeString.substring;

/**
 * 容器启动
 * BeanDefinition 扫描
 * Bean的生命周期[createBean->populateBean->initializeBean]
 * 单例与多例Bean
 * 依赖注入
 * AOP
 * Aware回调 ,NameAware回调
 * BeanPostProcessorBeforeInitialization
 * 初始化
 * BeanPostProcessorAfterInitialization
 *
 */
public class MyApplicationContext  implements BeanFactory {


    // 配置类AppConfig： 用来标注哪些是需要扫描的包， 以及扫描到之后如何初始化bean等
    private Class<?> configClass;

// singletonObjects：用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
// earlySingletonObjects：提前曝光的单例对象的cache，存放原始的 bean 对象（尚未填充属性），用于解决循环依赖
// singletonFactories：单例对象工厂的cache，存放 bean 工厂对象，用于解决循环依赖
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //单例池： beanName -> beanObj
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(); // 二级缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三级缓存


    // beanName -> BeanDefinition[bean的类型， 作用域等]
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();

    // BeanPostProcessorList 存储所有的BeanPostProcessor, 用于在bean初始化前后做一些额外的处理
    private final List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

    // 当前正在创建的bean集合，标记beanName; 用于解决循环依赖问题
    private final Set<String> singletonsCurrentlyInCreation =new HashSet<>();

    //装切面的集合
    private Set<Class<?>> aopSet = new CopyOnWriteArraySet<Class<?>>();

    /**
     * Disposable bean instances: bean name to disposable instance.
     * 一次性bean实例：bean----->instance
     */
    private final Map<String, Object> disposableBeans = new LinkedHashMap<>();


    /**
     * 扫描 -> 得到一系列 BeanDefinition，放入 beanDefinitionMap
     * @param configClass
     */
    private void scanBeanDefinition(Class<?> configClass) {
        // 获取AppConfig配置类上的@MyComponentScan注解信息
        MyComponentScan annotation = configClass.getAnnotation(MyComponentScan.class);
        if(annotation ==null) {
//            throw new RuntimeException("不是配置类");
            // todo 如果是不是配置类 ,直接加载本类
            BeanDefinition beanDefinition0= new BeanDefinition();
            beanDefinition0.setType(configClass);
            beanDefinition0.setScope("singleton");

            String name0 = configClass.getSimpleName().substring(0, 1).toLowerCase() + configClass.getSimpleName().substring(1);
            System.out.println(name0);
            beanDefinitionMap.put(name0, beanDefinition0);
            return;

        }

        String path = annotation.value();// com.zhang.service
        path = path.replace(".", "/"); // com/zhang/service

        // 扫描com.zhang.service包下的所有类：
        // 如果是.Java文件并且@Compentent标注初始化bean等
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        URL resourceUrl = classLoader.getResource(path);//获取 com/zhang/service目录下的文件

        File file = new File(resourceUrl.getFile());// 获取目录下的所有文件

        if (file.isDirectory()) {
            // 如果是目录 就继续扫描
            for (File f : file.listFiles()) {
                String fileName= f.getAbsoluteFile().toString();

                if (fileName.endsWith(".class")) {
                    // com\zhang\service\OrderService
                    String className = fileName.substring(fileName.indexOf("com"), fileName.lastIndexOf(".class"));
                    //com.zhang.service.OrderService
                    className = className.replace("\\", ".");
                    //System.out.println(className);

                    try {
                        // 判断扫描包下的类是否有@MyComponent注解
//                        Class<?> aClass = Class.forName(className);
                        Class<?> aClass = classLoader.loadClass(className);
                        if (aClass.isAnnotationPresent(MyComponent.class)) {
                            // 当前类是一个 Bean 对象
                            MyComponent myComponentAnno = aClass.getAnnotation(MyComponent.class);
                            String beanName = myComponentAnno.value(); // 获取@MyComponent(beanName)

                            if("".equals(beanName)) {
                                beanName = aClass.getSimpleName().substring(0,1).toLowerCase()+aClass.getSimpleName().substring(1); // 默认类名首字母小写
                            }
                            // 生成 BeanDefinition---->解析---->单例bean or 多例bean
                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setType(aClass);

                            //获取@MyScope注解，判断是单例还是多例
                            if (aClass.isAnnotationPresent(MyScope.class)) {
                                // 有值就是多例
                                MyScope myScopeAnno = aClass.getAnnotation(MyScope.class);
                                beanDefinition.setScope(myScopeAnno.value());
                            }else {
                                beanDefinition.setScope("singleton");
                            }
                            // beanName放入beanDefinitionMap中
                            beanDefinitionMap.put(beanName, beanDefinition);
                        }

                        // aop 说明是切面类
//                        if(aClass.isAnnotationPresent(Aspect.class)){
//                            aopSet.add(aClass);
//                            continue;
//                        }


                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }

    public MyApplicationContext(Class<?> configClass) { // 构造函数
        this.configClass = configClass; // 初始化配置类

        // 扫描component注解标注的bean，注册为beanDefinitionMap
        scanBeanDefinition(configClass);

        // 关键代码：将自身注册为单例 Bean
        singletonObjects.put("beanFactory", this);
        beanDefinitionMap.put("beanFactory", new BeanDefinition() {{
            setType(MyApplicationContext.class);
            setScope("singleton");
        }});

        // 注册所有的 BeanPostProcessor 到Spring 容器中
        registerBeanPostProcessors();

        // 提前实例化单例bean -----> new bean---->put--->singletonObjects
        beanDefinitionMap.forEach((beanName, beanDefinition) -> {
            if (beanDefinition.isSingleton()) {
                getBean(beanName); // 单例bean
            }
        });

        // 新增：执行AOP处理
        //doAop();

    }

    // AOP处理逻辑
//    private void doAop() {
//        if (aopSet == null || aopSet.size() == 0) return;
//
//        for (Class<?> aspectClass : aopSet) {
//            Method[] methods = aspectClass.getDeclaredMethods();
//            for (Method aspectMethod : methods) {
//                if (aspectMethod.isAnnotationPresent(Around.class)) {
//                    Around around = aspectMethod.getAnnotation(Around.class);
//                    String pointcut = around.value();
//
//                    try {
//                        // 解析切点表达式
//                        String className = pointcut.substring(0, pointcut.lastIndexOf("."));
//                        String methodName = pointcut.substring(pointcut.lastIndexOf(".") + 1);
//
//                        // 获取目标类
//                        Class<?> targetClass = Class.forName(className);
//
//                        // 获取bean名称（首字母小写）
//                        String simpleName = targetClass.getSimpleName();
//                        String beanName = simpleName.substring(0, 1).toLowerCase()
//                                + simpleName.substring(1);
//
//                        // 从容器中获取目标bean
//                        Object targetBean = singletonObjects.get(beanName);
//                        if (targetBean == null) {
//                            continue; // 如果不是单例或未创建，跳过
//                        }
//
//                        // 创建代理
//                        Object proxy = Proxy.newProxyInstance(
//                                targetClass.getClassLoader(),
//                                targetClass.getInterfaces(),
//                                (proxy1, method, args) -> {
//                                    // 检查是否是需要拦截的方法
//                                    if (method.getName().equals(methodName)) {
//                                        // 创建连接点
//                                        ProceedingJoinPoint joinPoint = new MethodInvocationProceedingJoinPoint(
//                                                method, args, targetBean, proxy1);
//
//                                        // 创建切面实例并执行通知
//                                        Object aspectInstance = aspectClass.getDeclaredConstructor().newInstance();
//                                        return aspectMethod.invoke(aspectInstance, joinPoint);
//                                    }
//                                    // 不需要拦截的方法直接调用
//                                    return method.invoke(targetBean, args);
//                                });
//
//                        // 替换容器中的bean
//                        singletonObjects.put(beanName, proxy);
//
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//                }
//            }
//        }
//    }


//    private void doAop2() {
//        if (aopSet == null || aopSet.size() == 0) return;
//
//        for (Class<?> aspectClass : aopSet) {
//            Method[] methods = aspectClass.getDeclaredMethods();
//            for (Method aspectMethod : methods) {
//                if (aspectMethod.isAnnotationPresent(Around.class)) {
//                    Around around = aspectMethod.getAnnotation(Around.class);
//                    String pointcut = around.value();
//
//                    try {
//                        // 解析切点表达式
//                        String className = pointcut.substring(0, pointcut.lastIndexOf("."));
//                        String methodName = pointcut.substring(pointcut.lastIndexOf(".") + 1);
//
//                        // 获取目标类
//                        Class<?> targetClass = Class.forName(className);
//
//                        // 获取bean名称
//                        String beanName = getBeanName(targetClass);
//
//                        // 从容器中获取目标bean
//                        Object targetBean = singletonObjects.get(beanName);
//                        if (targetBean == null || Proxy.isProxyClass(targetBean.getClass())) {
//                            continue;
//                        }
//
//                        // 创建方法拦截器
//                        MethodInterceptor interceptor = (invocation) -> {
//                            if (invocation.getMethod().getName().equals(methodName)) {
//                                Object aspectInstance = aspectClass.getDeclaredConstructor().newInstance();
//                                return aspectMethod.invoke(aspectInstance, invocation);
//                            }
//                            return invocation.proceed();
//                        };
//
//                        // 创建代理工厂
//                        ProxyFactory proxyFactory = new ProxyFactory(targetBean, List.of(interceptor));
//                        proxyFactory.setProxyTargetClass(true); // 强制使用CGLIB
//
//                        // 创建代理对象
//                        Object proxy = proxyFactory.getProxy();
//
//                        // 替换容器中的bean
//                        singletonObjects.put(beanName, proxy);
//
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//                }
//            }
//        }
//    }
    /**
     * 创建所有 Bean 后处理器，放入 singletonObjects 容器中，并注册到 beanPostProcessorList
     * 在后续的 preInstantiateSingletons() 初始化单例中，会先从容器中获取，获取不到再创建
     * Bean 后处理器属于单例，提前创建好了并放入容器，所以 Bean 后处理器并不会重复创建
     */
    public void registerBeanPostProcessors() {

        // 1.注册 AnnotationAwareAspectJAutoProxyCreator 作为 BeanPostProcessor
//        BeanDefinition beanDefinition = new BeanDefinition();
//        beanDefinition.setType(AnnotationAwareAspectJAutoProxyCreator.class);
//        beanDefinition.setScope("singleton");
//        beanDefinitionMap.put("AnnotationAwareAspectJAutoProxyCreator", beanDefinition);

        // 2.注册 AdvisorAutoProxyCreator 作为 BeanPostProcessor
        BeanDefinition beanDefinition2 = new BeanDefinition();
        beanDefinition2.setType(AdvisorAutoProxyCreator.class);
        beanDefinition2.setScope("singleton");
        beanDefinitionMap.put("AnnotationAwareAspectJAutoProxyCreator", beanDefinition2);

        // 3.将被扫描的。beanDefinitionMap，注册 BeanPostProcessor 类型的 Bean
        /*
          1. 从 beanDefinitionMap 中找出所有的 BeanPostProcessor
          2. 创建 BeanPostProcessor 放入容器
          3. 将创建的 BeanPostProcessor 注册到 beanPostProcessorList

          这里的写法：先注册的 BeanPostProcessor 会对后创建的 BeanPostProcessor 进行拦截处理，
          BeanPostProcessor 的创建走 bean 的生命周期流程
         */
        this.beanDefinitionMap.entrySet()
                .stream()
                .filter((entry) -> BeanPostProcessor.class.isAssignableFrom(entry.getValue().getType()))
                .forEach((entry) -> {
                    BeanPostProcessor beanPostProcessor = (BeanPostProcessor) getBean(entry.getKey());
                    this.beanPostProcessorList.add(beanPostProcessor);
                });
    }

    /**
     * 三个缓存中都没有bean，就只能去新建bean了
     * 创建bean对象
     * @param beanName
     * @param beanDefinition
     * @return
     */

    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        // 单例循环依赖检测： 若当前bean正在创建，则抛出异常
        if (beanDefinition.isSingleton()) {
            if (this.singletonsCurrentlyInCreation.contains(beanName)) {
                throw new IllegalStateException("创建名称为 " + beanName + "的单例bean时出错；因为 "
                        + "当前bean正在被创建");
            }
            this.singletonsCurrentlyInCreation.add(beanName);
        }

        try {
            // 一、实例化
            Class<?> aClass = beanDefinition.getType();
            Object instance = aClass.getDeclaredConstructor().newInstance();

            // 添加到三级缓存singletonFactories
            if (beanDefinition.isSingleton()) {
                // *******************把未初始化的bean放入三级缓存 **********************
                addSingletonFactory(beanName, () -> {
                    // todo 只有循环依赖时执行下面代码===============================调用 getSingleton 方法时，才会执行
                    for (BeanPostProcessor bp : beanPostProcessorList) {
                        if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                            // earlyReference可能是AOP对象
                            Object earlyReference = ((SmartInstantiationAwareBeanPostProcessor) bp).getEarlyBeanReference(instance, beanName);
                            if (earlyReference != instance) { //instance==原始对象
                                return earlyReference;
                            }
                        }
                    }
                    return instance;
                    // todo 只有有循环依赖时执行上面代码==================================
                });
            }

            // 二、依赖注入（可能触发循环依赖）
            populateBean(beanName, beanDefinition, instance);

            // 三、初始化阶段
            Object exposedObject = instance;
            exposedObject = initializeBean(beanName, beanDefinition, exposedObject);

            // 说明发生了循环依赖，在第二级缓存 earlySingletonObjects 中查看有没有当前 bean
            if (beanDefinition.isSingleton()) {
                // 再次获取getSingleton 对象：
                //          只有使用AOP的对象，能从二级缓存中获取到代理对象
                //          没有使用AOP的对象，从二级缓存中没有，但是能从三级缓存中获取到原始对象
                Object earlySingletonReference = getSingleton(beanName, false);
                if (earlySingletonReference != null) {
                    exposedObject = earlySingletonReference; // AOP对象
                }
            }


            // 注册销毁方法 如果 Bean单例且实现了 DisposableBean 接口（含 destroy() 方法
            if (beanDefinition.isSingleton() && DisposableBeanAdapter.hasDestroyMethod(instance, beanDefinition)) {
                this.disposableBeans.put(beanName, new DisposableBeanAdapter(instance, beanName, beanDefinition));
            }

            return exposedObject;
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } finally {
            if (beanDefinition.isSingleton()) {
                this.singletonsCurrentlyInCreation.remove(beanName);
            }
        }


    }

    /**
     * 添加原始对象工厂到三级缓存中
     * @param beanName
     * @param singletonFactory
     */
    private void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        synchronized (singletonObjects) {
            if (!this.singletonFactories.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);// 三级缓存，存放原始对象工厂
                this.earlySingletonObjects.remove(beanName);
            }
        }
    }
    /**
     * 初始化阶段，包含：Aware回调、初始化前、初始化、初始化后
     *
     * @param beanName
     * @param beanDefinition
     * @param bean
     * @return
     */
    private Object initializeBean(String beanName, BeanDefinition beanDefinition, Object bean) {
        // bean初始化阶段
        // 0️⃣ 各种 Aware 回调
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) (bean)).setBeanName(beanName);
        }
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) (bean)).setApplicationContext(this);
        }

        // 1️⃣ 初始化前处理
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
            bean = beanPostProcessor.postProcessBeforeInitialization(bean, beanName);
        }

        // 2️⃣ 属性设置后回调 ===== @PostConstruct 执行初始化方法
        if (bean instanceof InitializingBean) {
            ((InitializingBean) (bean)).afterPropertiesSet();
        }
        // TODO 执行 @Bean(initMethod = “myInit”) 指定的初始化方法（将初始化方法记录在 BeanDefinition 中）

        // 3️⃣ 初始化后处理，由 AnnotationAwareAspectJAutoProxyCreator 创建 aop 代理
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
            // todo ==== 如果是 AdvisorAutoProxyCreator，则向其中注册 Advisor
            if (beanPostProcessor instanceof AdvisorAutoProxyCreator) {
                // 各种logAfterReturningAdvice通知
                AdvisorAutoProxyCreator.registAdvisorBeanPostProcessor(beanPostProcessor);
            }
            bean = beanPostProcessor.postProcessAfterInitialization(bean, beanName);
        }
        // 如果有 aop 的话，这里的 bean 返回的是 aop 后的一个代理对象
        return bean;
    }


    /**
     * 依赖注入阶段，执行 bean 后处理器的 postProcessProperties 方法
     * @param beanName
     * @param beanDefinition
     * @param bean
     */
    private void populateBean1(String beanName, BeanDefinition beanDefinition, Object bean) throws IllegalAccessException, InvocationTargetException {
        Class clazz = beanDefinition.getType();

        // 1======解析字段上的 Autowired
        for (Field field : clazz.getDeclaredFields()) {
            // 判断当前属性是否加了@MyAutowired注解
            MyAutowired myAutowired = field.getAnnotation(MyAutowired.class);
            if (myAutowired != null) {
                field.setAccessible(true);

                boolean required = myAutowired.required();// 获取 required 属性
                Object fieldValue = null;

                // todo==== 查找 @MyQualifier 注解，如果存在就根据 value 来选择 Bean
                com.myspring.anno.MyQualifier myQualifier = field.getAnnotation(MyQualifier.class);

                if (myQualifier != null) {
                    // 根据 @MyQualifier 注解的值获取 Bean
                    String qualifierValue = myQualifier.value();
                    fieldValue = getBean(qualifierValue);
                    if (fieldValue == null) {
                        BeanDefinition definition = new BeanDefinition();
                        definition.setType(field.getType());
                        definition.setScope("singleton");
                        fieldValue = createBean(qualifierValue, definition);
                    }
                }else {
                    fieldValue = getBean(field.getName());
//                    } catch (RuntimeException e) {
//                        fieldValue = getBeanByType(field.getType()); // byType
//                    }
                }

                if (required &&fieldValue == null) {
                    // 如果required=true，则必须注入
                    throw new RuntimeException("要求必须注入，然而无法注入字段: " + field.getName());
                }

                field.set(bean, fieldValue); // filed = fieldValue;
            }
        }
        // 2========解析方法上的 Autowired
        for (Method method : clazz.getMethods()) {
            if (method.isAnnotationPresent(MyAutowired.class)) {
                // 编译时加上 -parameters 参数才能反射获取到参数名
                // 或者编译时加上 -g 参数，使用 ASM 获取到参数名
                String paramName = method.getParameters()[0].getName();
                method.invoke(bean, getBean(paramName)); // byName注入bean对象
            }
        }

    }

    /**
     * 依赖注入阶段，执行 bean 后处理器的 postProcessProperties 方法
     * @param beanDefinition
     * @param bean
     */
    private void populateBean(String beaName, BeanDefinition beanDefinition, Object bean) throws IllegalAccessException, InvocationTargetException {
        Class clazz = beanDefinition.getType();
        // 解析方法上的 Autowired
        for (Method method : clazz.getMethods()) {
            if (method.isAnnotationPresent(MyAutowired.class)) {
                // 编译时加上 -parameters 参数才能反射获取到参数名
                // 或者编译时加上 -g 参数，使用 ASM 获取到参数名
                String paramName = method.getParameters()[0].getName();
                method.invoke(bean, getBean(paramName));
            }
        }
        // 解析字段上的 Autowired
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(MyAutowired.class)) {
                field.setAccessible(true);
                // 去Spring 容器中找名为 field.getName() 的 bean，赋值给 bean
                field.set(bean, getBean(field.getName()));
            }
        }

    }

    /**
     * 根据beanName获取Bean对象
     * @param beanName
     * @return
     */
    public  Object getBean(String beanName) {
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        if (beanDefinition == null) {
            throw new NullPointerException();
        } else {
            // 单例
            if (beanDefinition.isSingleton()) {
                // 先去三个缓存中找，如果找到了就直接返回
                Object singletonObject = getSingleton(beanName, true);
                // 三处缓存都没有某个 bean，只能 create 了
                if (singletonObject == null) {
                    singletonObject = createBean(beanName, beanDefinition);
                    this.singletonObjects.put(beanName, singletonObject); // 完整的bean
                    this.earlySingletonObjects.remove(beanName);
                    this.singletonFactories.remove(beanName);
                }
                return singletonObject;
            } else { // 多例
                return createBean(beanName, beanDefinition);
            }
        }
    }




    /**
     * 尝试依次从缓存中取 bean对象
     * @param beanName
     * @param allowEarlyReference 是否应该创建早期引用。
     * bean 初始化后应该检查二级缓存是否提前创建了 bean，此时 allowEarlyReference 为 false，只检查到二级缓存即可
     * @return
     */
    private Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 第一级缓存： 单例池,存放初始化好的对象
        Object singletonObject = this.singletonObjects.get(beanName);
        // 如果一级缓存中没有，并且当前正在创建 bean（防止循环依赖）
        if (singletonObject == null&&this.singletonsCurrentlyInCreation.contains(beanName)) {
            // 第二级缓存：提前暴露的未完全初始化的对象
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 第三级缓存：单例对象工厂（可以生成早期引用）
                ObjectFactory<?> objectFactory = this.singletonFactories.get(beanName);
                if (objectFactory != null) {
                    singletonObject = objectFactory.getObject();
                    // 将早期引用放入二级缓存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
        return singletonObject;
    }

    /**
     * 根据beanType获取Bean对象
     * @param beanType
     * @return
     */
    public Object getBeanByType(Class<?> beanType){

        // 遍历所有已注册的 BeanDefinition
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            Class<?> beanClass = entry.getValue().getType(); //entry.getValue()=>BeanDefinition=>beanDefinition.classType

            // 判断传入的 beanType 是否可以接收来自 beanClass 类型的对象
            if (beanType.isAssignableFrom(beanClass)) {
                String beanName = entry.getKey();
                return getBean(beanName); // 获取 Bean 实例
            }
        }
        return null; // 未找到

    }


    public void close() {
        synchronized (this.disposableBeans) {
            Set<Map.Entry<String, Object>> entrySet = this.disposableBeans.entrySet();
            Iterator<Map.Entry<String, Object>> it = entrySet.iterator();
            while (it.hasNext()) {
                Map.Entry<String, Object> entry = it.next();
                String beanName = entry.getKey();
                DisposableBean bean = (DisposableBean) entry.getValue();
                try {
                    bean.destroy();
                } catch (Exception e) {
                    System.out.println("Destruction of bean with name '" + beanName + "' threw an exception：" + e);
                }
                it.remove();
            }
        }
        // Clear all cached singleton instances in this registry.
        this.singletonObjects.clear();
        this.earlySingletonObjects.clear();
        this.singletonFactories.clear();
    }



    public List<Class<?>> getAllBeanClass() {
        return beanDefinitionMap.values()
                .stream()
                .map((Function<BeanDefinition, Class<?>>) BeanDefinition::getType)
                .collect(Collectors.toList());
    }


}
